package com.hardson.toolkit.util;

import com.hardson.toolkit.interfaces.ICallback;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 线程工具类
 * 注意：这是一个有缺陷的设计，工具类中的线程池默认是5个，并且这个线程池是全局的
 *
 * @author hardson
 * @date 2023/8/23 下午3:30
 */
public class ThreadUtils {

    private static final ExecutorService mainExecutor;
    private static int poolSize = 5;

    static {
        mainExecutor = Executors.newFixedThreadPool(poolSize);
    }

    /**
     * 初始化线程池
     *
     * @param poolSize0:
     * @author hardson
     * @date 2023/8/23 下午3:50
     */
    public void initPoolSize(int poolSize0) {
        poolSize = poolSize0;
        try {
            if (!mainExecutor.isShutdown()) {
                mainExecutor.awaitTermination(30, TimeUnit.SECONDS);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            mainExecutor.shutdown();
        }
    }

    /**
     * 在线程池中启动线程
     *
     * @param runnable 线程对象
     * @author hardson
     * @date 2023/8/23 上午10:21
     */
    public static void run(final Runnable runnable) {
        mainExecutor.execute(runnable);
    }

    /**
     * 立即执行线程
     *
     * @param runnable 线程对象
     * @author hardson
     * @date 2023/8/23 上午10:23
     */
    public static void runImmediately(final Runnable runnable) {
        new Thread(runnable).start();
    }

    /**
     * 延时将回调任务放入线程池中执行
     *
     * @param callback 通过回调执行的任务
     * @param delay    延时毫秒数
     * @author hardson
     * @date 2023/8/23 下午2:53
     */
    public static void runDelay(final ICallback callback, long delay) {

        mainExecutor.execute(() -> {
            sleep(delay);
            callback.execute();
        });
    }

    /**
     * 当前线程睡眠一定的时间
     *
     * @param millis 睡眠时间毫秒数
     * @author hardson
     * @date 2023/8/23 下午3:15
     */
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            //不处理
        }
    }

    /**
     * CountDownLatch等待阻塞的便捷方法，封闭了中断异常
     *
     * @param latch CountDownLatch
     * @author hardson
     * @date 2023/8/23 下午3:21
     */
    public static void countDownLatchAwait(CountDownLatch latch) {
        try {
            latch.await();
        } catch (InterruptedException e) {
            //不处理
        }
    }
}
